package com.gaj.util;

import org.apache.poi.xwpf.usermodel.*;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class WordTableReader {

    private static final String DICT_PATH = "D:\\idea_projects\\gajSpringBoot\\doc\\sql\\字典数据";

    public static void main(String[] args) throws IOException {
        // 输入文件路径
        String filePath = "D:\\users\\Desktop\\BaiduSyncdisk\\工作\\外包\\BJCM政法智能办案平台中心平台项目技术接口标准V4.5.4.2\\03-政法智能办案平台中心平台项目业务代码标准v4.5.2-第四部分.docx";

        // 加载文档
        FileInputStream fis = new FileInputStream(filePath);
        XWPFDocument document = new XWPFDocument(fis);

        // 直接获取文档中的所有表格，避免重复计算
        List<XWPFTable> tables = document.getTables();
        System.out.println("文档中总共有 " + tables.size() + " 个表格");

        // 获取排序后的文件名列表
        String[] sortedFileNames = getSortedFileNames();
        System.out.println("字典数据文件夹中有 " + sortedFileNames.length + " 个文件");

        // 将每个表格内容写入对应的文件
        int maxTables = Math.min(tables.size(), sortedFileNames.length);
        for (int tableIndex = 0; tableIndex < maxTables; tableIndex++) {
            XWPFTable xwpfTable = tables.get(tableIndex);


            printTableContent(xwpfTable);
            continue;

            //String fileName = sortedFileNames[tableIndex];
            //
            //System.out.println("正在处理表格 " + (tableIndex + 1) + " -> 文件: " + fileName);
            //
            //// 将表格内容写入文件
            //writeTableToFile(xwpfTable, fileName);
        }

        // 关闭资源
        document.close();
        fis.close();

        System.out.println("所有表格内容已写入对应文件！");
    }

    // 打印表格内容并对齐
    private static void printTableContent(XWPFTable table) {
        List<XWPFTableRow> rows = table.getRows();
        if (rows.isEmpty()) return;

        // 检测表格结构，判断是否有自动编号
        boolean hasAutoNumbering = detectAutoNumbering(rows);
        //System.out.println("检测到自动编号: " + hasAutoNumbering);

        // 打印每一行的内容
        for (int rowIndex = 0; rowIndex < rows.size(); rowIndex++) {
            XWPFTableRow row = rows.get(rowIndex);

            // 打印当前行的所有单元格内容，保证对齐
            for (int i = 0; i < row.getTableCells().size(); i++) {
                String cellText = "";

                // 如果检测到有自动编号且是第一列，尝试从段落中提取编号
                if (hasAutoNumbering && i == 0 && rowIndex > 0) { // 跳过标题行
                    cellText = extractAutoNumber(row.getTableCells().get(i), rowIndex);
                } else {
                    cellText = row.getTableCells().get(i).getText();
                }

                System.out.print(padRight(cellText, 25));  // 调整列宽以对齐，25为宽度
            }
            System.out.println();  // 换行
        }
    }

    // 检测表格是否有自动编号
    private static boolean detectAutoNumbering(List<XWPFTableRow> rows) {
        if (rows.size() < 2) return false;

        // 检查前几行第一列的内容，如果都是空的但行数较多，可能有自动编号
        int emptyFirstColumnCount = 0;
        int totalCheckedRows = 0;

        for (int i = 1; i < Math.min(rows.size(), 6); i++) { // 跳过标题行，检查前5行
            XWPFTableRow row = rows.get(i);
            if (row.getTableCells().isEmpty()) continue;

            XWPFTableCell firstCell = row.getTableCells().get(0);
            String firstCellText = firstCell.getText().trim();
            totalCheckedRows++;

            //System.out.println("第" + (i+1) + "行第一列内容: '" + firstCellText + "'");

            // 检查是否有段落编号信息
            if (firstCellText.isEmpty() && !firstCell.getParagraphs().isEmpty()) {
                XWPFParagraph paragraph = firstCell.getParagraphs().get(0);
                if (paragraph.getNumID() != null) {
                    //System.out.println("  发现段落编号ID: " + paragraph.getNumID());
                    emptyFirstColumnCount++;
                }
            } else if (firstCellText.isEmpty()) {
                emptyFirstColumnCount++;
            }
        }

        //System.out.println("检查了" + totalCheckedRows + "行，其中" + emptyFirstColumnCount + "行第一列为空");

        // 如果大部分行的第一列都为空，可能存在自动编号
        return emptyFirstColumnCount >= 2;
    }

    // 尝试从单元格的段落中提取自动编号
    private static String extractAutoNumber(XWPFTableCell cell, int rowIndex) {
        try {
            List<XWPFParagraph> paragraphs = cell.getParagraphs();
            if (paragraphs.isEmpty()) return "";

            XWPFParagraph paragraph = paragraphs.get(0);
            String paragraphText = paragraph.getText().trim();

            // 如果单元格有实际文本内容，直接返回
            if (!paragraphText.isEmpty()) {
                // 检查是否包含数字编号
                if (paragraphText.matches("^\\d+\\s+.*")) {
                    return paragraphText.split("\\s+")[0];
                }
                return paragraphText;
            }

            // 检查段落是否有编号格式
            if (paragraph.getNumID() != null) {
                // 有自动编号格式，手动生成序号
                return String.valueOf(rowIndex);
            }

            // 如果单元格为空但有其他内容（如自动编号），尝试其他方法
            // 检查是否有运行（runs）但文本为空的情况
            if (!paragraph.getRuns().isEmpty()) {
                // 可能是自动编号，返回行号作为替代
                return String.valueOf(rowIndex);
            }

            return ""; // 完全为空
        } catch (Exception e) {
            // 如果出现异常，返回行号作为备用方案
            return String.valueOf(rowIndex);
        }
    }


    // 获取排序后的文件名列表（从FtpDirBuilder.java移植）
    private static String[] getSortedFileNames() {
        File dictDir = new File(DICT_PATH);
        if (!dictDir.exists() || !dictDir.isDirectory()) {
            System.err.println("字典数据目录不存在: " + DICT_PATH);
            return new String[0];
        }

        String[] fileList = dictDir.list();
        if (fileList == null) {
            return new String[0];
        }

        // 使用自然排序进行排序
        Arrays.sort(fileList, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return naturalCompare(o1, o2);
            }
        });

        return fileList;
    }

    // 自然排序方法（从FtpDirBuilder.java移植）
    private static int naturalCompare(String o1, String o2) {
        // 使用正则表达式来分割文件名中的数字和字母
        String[] parts1 = o1.split("(?<=\\D)(?=\\d)|(?<=\\d)(?=\\D)");
        String[] parts2 = o2.split("(?<=\\D)(?=\\d)|(?<=\\d)(?=\\D)");

        int length = Math.min(parts1.length, parts2.length);

        for (int i = 0; i < length; i++) {
            // 比较数字
            if (isNumeric(parts1[i]) && isNumeric(parts2[i])) {
                int num1 = Integer.parseInt(parts1[i]);
                int num2 = Integer.parseInt(parts2[i]);
                if (num1 != num2) {
                    return Integer.compare(num1, num2);
                }
            } else {
                // 如果是字符串部分，直接按字典顺序比较
                int result = parts1[i].compareTo(parts2[i]);
                if (result != 0) {
                    return result;
                }
            }
        }

        return Integer.compare(parts1.length, parts2.length);
    }

    // 判断是否为数字（从FtpDirBuilder.java移植）
    private static boolean isNumeric(String str) {
        return str.matches("\\d+");
    }

    // 将表格内容写入文件
    private static void writeTableToFile(XWPFTable table, String fileName) {
        try {
            File targetFile = new File(DICT_PATH, fileName);

            // 创建文件（如果不存在）
            if (!targetFile.exists()) {
                targetFile.createNewFile();
            }

            // 写入表格内容
            try (FileWriter writer = new FileWriter(targetFile)) {
                List<XWPFTableRow> rows = table.getRows();
                if (rows.isEmpty()) {
                    writer.write(""); // 空表格
                    return;
                }

                // 检测表格结构，判断是否有自动编号
                boolean hasAutoNumbering = detectAutoNumbering(rows);

                // 写入每一行的内容
                for (int rowIndex = 0; rowIndex < rows.size(); rowIndex++) {
                    XWPFTableRow row = rows.get(rowIndex);

                    // 构建当前行的内容
                    StringBuilder rowContent = new StringBuilder();

                    // 处理当前行的所有单元格内容
                    for (int i = 0; i < row.getTableCells().size(); i++) {
                        String cellText = "";

                        // 如果检测到有自动编号且是第一列，尝试从段落中提取编号
                        if (hasAutoNumbering && i == 0 && rowIndex > 0) { // 跳过标题行
                            cellText = extractAutoNumber(row.getTableCells().get(i), rowIndex);
                        } else {
                            cellText = row.getTableCells().get(i).getText();
                        }

                        // 使用制表符分隔列
                        if (i > 0) {
                            rowContent.append("\t");
                        }
                        rowContent.append(cellText);
                    }

                    // 写入行内容并换行
                    writer.write(rowContent.toString());
                    writer.write("\n");
                }
            }

            System.out.println("成功写入文件: " + fileName);

        } catch (IOException e) {
            System.err.println("写入文件失败: " + fileName + ", 错误: " + e.getMessage());
        }
    }

    // 对字符串进行右填充，使其达到指定长度
    private static String padRight(String str, int length) {
        if (str == null) {
            return String.format("%-" + length + "s", "");
        }
        return String.format("%-" + length + "s", str);
    }
}
